home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / cocktail / cg.lha / cg / src / EvalC.mi < prev    next >
Text File  |  1992-11-24  |  22KB  |  781 lines
  1. IMPLEMENTATION MODULE EvalC;
  2.  
  3.  
  4.  
  5.  
  6.  
  7.  
  8.  
  9.  
  10.  
  11.  
  12.  
  13.  
  14.  
  15. IMPORT SYSTEM, System, IO, Tree;
  16. (* line 9 "" *)
  17.  
  18.  
  19. FROM SYSTEM    IMPORT ADR;
  20. FROM IO        IMPORT WriteS, WriteNl;
  21. FROM StringMem    IMPORT Length, WriteString;
  22. FROM Idents    IMPORT tIdent, GetStringRef;
  23. FROM Texts    IMPORT WriteText;
  24. FROM Sets    IMPORT IsElement;
  25. FROM TreeC1    IMPORT BSS;
  26. FROM TreeC2    IMPORT WriteLine;
  27. FROM EvalC3    IMPORT ToBit0;
  28.  
  29. FROM Tree    IMPORT
  30.    NoTree    , tTree        , Child        , ClassCount    ,
  31.    Computed    , Reverse    , Write        , Read        ,
  32.    Inherited    , Synthesized    , Input        , Output    ,
  33.    Stack    , Variable    , NoCodeClass    ,
  34.    CopyDef    , CopyUse    , Thread    , Virtual    , 
  35.    Test        , Left        , Right        ,
  36.    NonBaseComp    , First        , Dummy        , Trace        ,
  37.    Options    , TreeRoot    , iModule    , iMain        ,
  38.    itTree    , ForallClasses    , f        , WI    , WN    ,
  39.    IdentifyClass, IdentifyAttribute, GrammarClass, cOAG        ,
  40.    MaxVisit    ;
  41.  
  42. VAR
  43.    n        : SHORTCARD;
  44.    Node        ,
  45.    Attr        ,
  46.    ChildsClass    : tTree;
  47.  
  48.  
  49.  
  50.  
  51.  
  52.  
  53.  
  54.  
  55.  
  56.  
  57.  
  58.  
  59.  
  60.  
  61.  
  62.  
  63.  
  64.  
  65.  
  66.  
  67.  
  68.  
  69.  
  70.  
  71.  
  72.  
  73.  
  74.  
  75.  
  76.  
  77.  
  78.  
  79.  
  80.  
  81.  
  82.  
  83.  
  84.  
  85.  
  86.  
  87.  
  88.  
  89.  
  90.  
  91.  
  92.  
  93.  
  94.  
  95.  
  96.  
  97.  
  98.  
  99.  
  100.  
  101.  
  102.  
  103.  
  104.  
  105.  
  106.  
  107.  
  108.  
  109.  
  110.  
  111.  
  112.  
  113.  
  114.  
  115.  
  116.  
  117.  
  118.  
  119.  
  120.  
  121.  
  122.  
  123.  
  124.  
  125.  
  126.  
  127.  
  128.  
  129.  
  130.  
  131.  
  132.  
  133.  
  134.  
  135.  
  136.  
  137.  
  138.  
  139.  
  140.  
  141.  
  142.  
  143.  
  144.  
  145.  
  146.  
  147.  
  148.  
  149.  
  150.  
  151.  
  152.  
  153. PROCEDURE yyAbort (yyFunction: ARRAY OF CHAR);
  154.  BEGIN
  155.   IO.WriteS (IO.StdError, 'Error: module EvalC, routine ');
  156.   IO.WriteS (IO.StdError, yyFunction);
  157.   IO.WriteS (IO.StdError, ' failed');
  158.   IO.WriteNl (IO.StdError);
  159.   Exit;
  160.  END yyAbort;
  161.  
  162. PROCEDURE yyIsEqual (yya, yyb: ARRAY OF SYSTEM.BYTE): BOOLEAN;
  163.  VAR yyi    : INTEGER;
  164.  BEGIN
  165.   FOR yyi := 0 TO INTEGER (HIGH (yya)) DO
  166.    IF yya [yyi] # yyb [yyi] THEN RETURN FALSE; END;
  167.   END;
  168.   RETURN TRUE;
  169.  END yyIsEqual;
  170.  
  171. PROCEDURE EvalDefC (t: Tree.tTree);
  172.  VAR yyTempo: RECORD CASE : INTEGER OF
  173.  END; END;
  174.  BEGIN
  175.   IF t = Tree.NoTree THEN RETURN; END;
  176.   IF (t^.Kind = Tree.Ag) THEN
  177. (* line 43 "" *)
  178.      WITH t^.Ag DO
  179. (* line 43 "" *)
  180.       
  181.     WriteS (f, "# ifndef yy"); WI (EvalName); WriteNl (f);
  182.     WriteS (f, "# define yy"); WI (EvalName); WriteNl (f);
  183.     WriteNl (f);
  184.     WriteS (f, "# if defined __STDC__ | defined __cplusplus"); WriteNl (f);
  185.     WriteS (f, "# define ARGS(parameters)    parameters"); WriteNl (f);
  186.     WriteS (f, "# else"); WriteNl (f);
  187.     WriteS (f, "# define ARGS(parameters)    ()"); WriteNl (f);
  188.     WriteS (f, "# endif"); WriteNl (f);
  189.     WriteNl (f);
  190.     WriteS (f, '# include "'); WI (iMain); WriteS (f, '.h"'); WriteNl (f);
  191.     WriteNl (f);
  192.     WriteLine (EvalCodes^.Codes.ImportLine);
  193.     WriteText (f, EvalCodes^.Codes.Import);
  194.     Node := Modules;
  195.     WHILE Node^.Kind = Tree.Module DO
  196.        WriteLine (Node^.Module.EvalCodes^.Codes.ImportLine);
  197.        WriteText (f, Node^.Module.EvalCodes^.Codes.Import);
  198.        Node := Node^.Module.Next;
  199.     END;
  200.     WriteLine (EvalCodes^.Codes.ExportLine);
  201.     WriteText (f, EvalCodes^.Codes.Export);
  202.     Node := Modules;
  203.     WHILE Node^.Kind = Tree.Module DO
  204.        WriteLine (Node^.Module.EvalCodes^.Codes.ExportLine);
  205.        WriteText (f, Node^.Module.EvalCodes^.Codes.Export);
  206.        Node := Node^.Module.Next;
  207.     END;
  208.     WriteNl (f);
  209.     WriteS (f, "extern void "); WI (EvalName); WriteS (f, " ARGS(("); WI (itTree); WriteS (f, " yyt));"); WriteNl (f);
  210.     WriteS (f, "extern void Begin"); WI (EvalName); WriteS (f, " ();"); WriteNl (f);
  211.     WriteS (f, "extern void Close"); WI (EvalName); WriteS (f, " ();"); WriteNl (f);
  212.     WriteNl (f);
  213.     WriteS (f, "# endif"); WriteNl (f);
  214. ;
  215.       RETURN;
  216.      END;
  217.  
  218.   END;
  219.  END EvalDefC;
  220.  
  221. PROCEDURE EvalImplHead (t: Tree.tTree);
  222.  VAR yyTempo: RECORD CASE : INTEGER OF
  223.  END; END;
  224.  BEGIN
  225.   IF t = Tree.NoTree THEN RETURN; END;
  226.   IF (t^.Kind = Tree.Ag) THEN
  227. (* line 81 "" *)
  228.      WITH t^.Ag DO
  229. (* line 81 "" *)
  230.       
  231.     WriteS (f, "# define DEP(a, b) a"); WriteNl (f);
  232.     WriteS (f, "# define SELF yyt"); WriteNl (f);
  233.     WriteS (f, '# include "'); WI (EvalName); WriteS (f, '.h"'); WriteNl (f);
  234.       IF IsElement (ORD ('Y'), Options) OR
  235.          IsElement (ORD ('Z'), Options) OR
  236.          IsElement (ORD ('L'), Options) THEN
  237.     WriteS (f, '# include <stdio.h>'); WriteNl (f);
  238.       END;
  239.       IF IsElement (ORD ('Y'), Options) OR
  240.          IsElement (ORD ('Z'), Options) THEN
  241.     WriteS (f, "# ifdef __cplusplus"); WriteNl (f);
  242.     WriteS (f, 'extern "C" {'); WriteNl (f);
  243.     WriteS (f, '# include "Idents.h"'); WriteNl (f);
  244.     WriteS (f, '# include "Sets.h"'); WriteNl (f);
  245.     WriteS (f, "}"); WriteNl (f);
  246.     WriteS (f, "# else"); WriteNl (f);
  247.     WriteS (f, '# include "Idents.h"'); WriteNl (f);
  248.     WriteS (f, '# include "Sets.h"'); WriteNl (f);
  249.     WriteS (f, "# endif"); WriteNl (f);
  250.       END;
  251.       IF IsElement (ORD ('9'), Options) THEN
  252.     WriteS (f, "# ifdef __cplusplus"); WriteNl (f);
  253.     WriteS (f, 'extern "C" {'); WriteNl (f);
  254.     WriteS (f, '# include "General.h"'); WriteNl (f);
  255.     WriteS (f, "}"); WriteNl (f);
  256.     WriteS (f, "# else"); WriteNl (f);
  257.     WriteS (f, '# include "General.h"'); WriteNl (f);
  258.     WriteS (f, "# endif"); WriteNl (f);
  259.     WriteNl (f);
  260.     WriteS (f, "static int xxStack;"); WriteNl (f);
  261.       END;
  262.     WriteLine (EvalCodes^.Codes.GlobalLine);
  263.     WriteText (f, EvalCodes^.Codes.Global);
  264.     Node := Modules;
  265.     WHILE Node^.Kind = Tree.Module DO
  266.        WriteLine (Node^.Module.EvalCodes^.Codes.GlobalLine);
  267.        WriteText (f, Node^.Module.EvalCodes^.Codes.Global);
  268.        Node := Node^.Module.Next;
  269.     END;
  270.     WriteNl (f);
  271.       IF IsElement (ORD ('X'), Options) THEN
  272.     WriteS (f, '# include "yy'); WI (iModule); WriteS (f, '.w"'); WriteNl (f);
  273.     WriteS (f, "# define yyWrite"); WI (iMain); WriteS (f, "(a) Write"); WI (iMain); WriteS (f, " (yyf, a)"); WriteNl (f);
  274.       END;
  275.     WriteNl (f);
  276.     WriteS (f, "static char yyb;"); WriteNl (f);
  277.       IF IsElement (ORD ('Y'), Options) OR
  278.          IsElement (ORD ('Z'), Options) THEN
  279.     WriteNl (f);
  280.     WriteS (f, "# define yyTrace    true"); WriteNl (f);
  281.     WriteNl (f);
  282.     WriteS (f, "static char * yyTypeName ["); WN (ClassCount); WriteS (f, " + 1] = { 0,"); WriteNl (f);
  283.     ForallClasses (Classes, TypeName);
  284.     WriteS (f, "};"); WriteNl (f);
  285.     WriteNl (f);
  286.     WriteS (f, "static void yyWriteType"); WriteNl (f);
  287.     WriteS (f, "# if defined __STDC__ | defined __cplusplus"); WriteNl (f);
  288.     WriteS (f, " ("); WI (itTree); WriteS (f, " yyt)"); WriteNl (f);
  289.     WriteS (f, "# else"); WriteNl (f);
  290.     WriteS (f, " (yyt) "); WI (itTree); WriteS (f, " yyt;"); WriteNl (f);
  291.     WriteS (f, "# endif"); WriteNl (f);
  292.     WriteS (f, "{"); WriteNl (f);
  293.     WriteS (f, " char * yys = yyTypeName [yyt->Kind];"); WriteNl (f);
  294.     WriteS (f, " register int yyi = 16 - strlen (yys);"); WriteNl (f);
  295.     WriteS (f, ' (void) printf ("%s", yys);'); WriteNl (f);
  296.     WriteS (f, " while (yyi -- > 0) (void) putc (' ', stdout);"); WriteNl (f);
  297.     WriteS (f, "}"); WriteNl (f);
  298.       END;
  299.       IF IsElement (ORD ('X'), Options) THEN
  300.     WriteNl (f);
  301.     WriteS (f, "static FILE * yyf = stdout;"); WriteNl (f);
  302.     WriteNl (f);
  303.     WriteS (f, "static void yyWriteHex"); WriteNl (f);
  304.     WriteS (f, "# if defined __STDC__ | defined __cplusplus"); WriteNl (f);
  305.     WriteS (f, " (unsigned char * yyx, int yysize)"); WriteNl (f);
  306.     WriteS (f, "# else"); WriteNl (f);
  307.     WriteS (f, " (yyx, yysize) unsigned char * yyx; int yysize;"); WriteNl (f);
  308.     WriteS (f, "# endif"); WriteNl (f);
  309.     WriteS (f, '{ register int yyi; for (yyi = 0; yyi < yysize; yyi ++) (void) printf ("%02x ", yyx [yyi]); }'); WriteNl (f);
  310.     WriteNl (f);
  311.     WriteS (f, "static void yyWriteNl () { if (yyTrace) { (void) putc ('\n', stdout); (void) fflush (stdout); } }"); WriteNl (f);
  312.       END;
  313.       IF IsElement (ORD ('X'), Options) THEN
  314.     WriteNl (f);
  315.     WriteS (f, "static void yyWriteEval"); WriteNl (f);
  316.     WriteS (f, "# if defined __STDC__ | defined __cplusplus"); WriteNl (f);
  317.     WriteS (f, " ("); WI (itTree); WriteS (f, " yyt, char * yys)"); WriteNl (f);
  318.     WriteS (f, "# else"); WriteNl (f);
  319.     WriteS (f, " (yyt, yys) "); WI (itTree); WriteS (f, " yyt; char * yys;"); WriteNl (f);
  320.     WriteS (f, "# endif"); WriteNl (f);
  321.     WriteS (f, "{"); WriteNl (f);
  322.     WriteS (f, " if (yyTrace) {"); WriteNl (f);
  323.     WriteS (f, "  register int yyi = 24 - strlen (yys);"); WriteNl (f);
  324.     WriteS (f, "  yyWriteType (yyt);"); WriteNl (f);
  325.     WriteS (f, '  (void) printf (" e %s", yys);'); WriteNl (f);
  326.     WriteS (f, "  while (yyi -- > 0) (void) putc (' ', stdout);"); WriteNl (f);
  327.     WriteS (f, '  (void) printf (" = ");'); WriteNl (f);
  328.     WriteS (f, "  (void) fflush (stdout);"); WriteNl (f);
  329.     WriteS (f, " }"); WriteNl (f);
  330.     WriteS (f, "}"); WriteNl (f);
  331.       ELSIF IsElement (ORD ('Y'), Options) THEN
  332.     WriteNl (f);
  333.     WriteS (f, "static void yyWriteEval"); WriteNl (f);
  334.     WriteS (f, "# if defined __STDC__ | defined __cplusplus"); WriteNl (f);
  335.     WriteS (f, " ("); WI (itTree); WriteS (f, " yyt, char * yys)"); WriteNl (f);
  336.     WriteS (f, "# else"); WriteNl (f);
  337.     WriteS (f, " (yyt, yys) "); WI (itTree); WriteS (f, " yyt; char * yys;"); WriteNl (f);
  338.     WriteS (f, "# endif"); WriteNl (f);
  339.     WriteS (f, "{"); WriteNl (f);
  340.     WriteS (f, " if (yyTrace) {"); WriteNl (f);
  341.     WriteS (f, "  yyWriteType (yyt);"); WriteNl (f);
  342.     WriteS (f, '  (void) printf (" e %s\n", yys);'); WriteNl (f);
  343.     WriteS (f, "  (void) fflush (stdout);"); WriteNl (f);
  344.     WriteS (f, " }"); WriteNl (f);
  345.     WriteS (f, "}"); WriteNl (f);
  346.       END;
  347.       IF IsElement (ORD ('Z'), Options) THEN
  348.     WriteNl (f);
  349.     WriteS (f, "static void yyWriteVisit"); WriteNl (f);
  350.     WriteS (f, "# if defined __STDC__ | defined __cplusplus"); WriteNl (f);
  351.     WriteS (f, " ("); WI (itTree); WriteS (f, " yyt, char * yys)"); WriteNl (f);
  352.     WriteS (f, "# else"); WriteNl (f);
  353.     WriteS (f, " (yyt, yys) "); WI (itTree); WriteS (f, " yyt; char * yys;"); WriteNl (f);
  354.     WriteS (f, "# endif"); WriteNl (f);
  355.     WriteS (f, "{"); WriteNl (f);
  356.     WriteS (f, " if (yyTrace) {"); WriteNl (f);
  357.     WriteS (f, "  yyWriteType (yyt);"); WriteNl (f);
  358.     WriteS (f, '  (void) printf (" v %s\n", yys);'); WriteNl (f);
  359.     WriteS (f, "  (void) fflush (stdout);"); WriteNl (f);
  360.     WriteS (f, " }"); WriteNl (f);
  361.     WriteS (f, "}"); WriteNl (f);
  362.     WriteNl (f);
  363.     WriteS (f, "static void yyVisitParent"); WriteNl (f);
  364.     WriteS (f, "# if defined __STDC__ | defined __cplusplus"); WriteNl (f);
  365.     WriteS (f, " ("); WI (itTree); WriteS (f, " yyt)"); WriteNl (f);
  366.     WriteS (f, "# else"); WriteNl (f);
  367.     WriteS (f, " (yyt) "); WI (itTree); WriteS (f, " yyt;"); WriteNl (f);
  368.     WriteS (f, "# endif"); WriteNl (f);
  369.     WriteS (f, '{ yyWriteVisit (yyt, "parent"); }'); WriteNl (f);
  370.       END;
  371. ;
  372.       RETURN;
  373.      END;
  374.  
  375.   END;
  376.  END EvalImplHead;
  377.  
  378. PROCEDURE EvalImplC (t: Tree.tTree);
  379.  VAR yyTempo: RECORD CASE : INTEGER OF
  380.  END; END;
  381.  BEGIN
  382.   IF t = Tree.NoTree THEN RETURN; END;
  383.   IF (t^.Kind = Tree.Ag) THEN
  384. (* line 226 "" *)
  385.      WITH t^.Ag DO
  386. (* line 226 "" *)
  387.       
  388.     EvalImplHead (t);
  389.     WriteNl (f);
  390.     FOR n := 1 TO MaxVisit DO
  391.        WriteS (f, "static void yyVisit"); WN (n); WriteS (f, " ARGS((register "); WI (itTree); WriteS (f, " yyt));"); WriteNl (f);
  392.     END;
  393.     WriteNl (f);
  394.     WriteS (f, "void "); WI (EvalName); WriteNl (f);
  395.     WriteS (f, "# if defined __STDC__ | defined __cplusplus"); WriteNl (f);
  396.     WriteS (f, " ("); WI (itTree); WriteS (f, " yyt)"); WriteNl (f);
  397.     WriteS (f, "# else"); WriteNl (f);
  398.     WriteS (f, " (yyt) "); WI (itTree); WriteS (f, " yyt;"); WriteNl (f);
  399.     WriteS (f, "# endif"); WriteNl (f);
  400.       IF NOT IsElement (ORD ('9'), Options) THEN
  401.     WriteS (f, "{ "); IF MaxVisit > 0 THEN WriteS (f, "yyVisit1 (yyt); "); END; WriteS (f, "}"); WriteNl (f);
  402.       ELSE
  403.     WriteS (f, "{"); WriteNl (f);
  404.     WriteS (f, " char xxHigh;"); WriteNl (f);
  405.     WriteS (f, " xxStack = 1000000000;"); WriteNl (f);
  406.     IF MaxVisit > 0 THEN
  407.        WriteS (f, " yyVisit1 (yyt);"); WriteNl (f);
  408.     END;
  409.     WriteS (f, ' (void) printf ("Stacksize %d\n", (int) & xxHigh - xxStack);'); WriteNl (f);
  410.     WriteS (f, "}"); WriteNl (f);
  411.       END;
  412.     WriteNl (f);
  413.     FOR n := 1 TO MaxVisit DO
  414.        WriteS (f, "static void yyVisit"); WN (n); WriteNl (f);
  415.        WriteS (f, "# if defined __STDC__ | defined __cplusplus"); WriteNl (f);
  416.        WriteS (f, " (register "); WI (itTree); WriteS (f, " yyt)"); WriteNl (f);
  417.        WriteS (f, "# else"); WriteNl (f);
  418.        WriteS (f, " (yyt) register "); WI (itTree); WriteS (f, " yyt;"); WriteNl (f);
  419.        WriteS (f, "# endif"); WriteNl (f);
  420.        WriteS (f, "{"); WriteNl (f);
  421.        WriteLine (EvalCodes^.Codes.LocalLine);
  422.        WriteText (f, EvalCodes^.Codes.Local);
  423.        Node := Modules;
  424.        WHILE Node^.Kind = Tree.Module DO
  425.        WriteLine (Node^.Module.EvalCodes^.Codes.LocalLine);
  426.           WriteText (f, Node^.Module.EvalCodes^.Codes.Local);
  427.           Node := Node^.Module.Next;
  428.        END;
  429.       IF IsElement (ORD ('9'), Options) THEN
  430.        WriteS (f, " char xxLow;"); WriteNl (f);
  431.        WriteS (f, " xxStack = Min (xxStack, (int) & xxLow);"); WriteNl (f);
  432.       END;
  433.        WriteNl (f);
  434.        WriteS (f, " switch (yyt->Kind) {"); WriteNl (f);
  435.        IF cOAG IN GrammarClass THEN        (* generate evaluator    *)
  436.           ForallClasses (Classes, GenEvaluator);
  437.        END;
  438.        WriteS (f, " default: ;"); WriteNl (f);
  439.       IF IsElement (ORD ('Z'), Options) THEN
  440.        WriteS (f, "  yyVisitParent (yyt);"); WriteNl (f);
  441.       END;
  442.        WriteS (f, " }"); WriteNl (f);
  443.        WriteS (f, "}"); WriteNl (f);
  444.        WriteNl (f);
  445.     END;
  446.     WriteS (f, "void Begin"); WI (EvalName); WriteS (f, " ()"); WriteNl (f);
  447.     WriteS (f, "{"); WriteNl (f);
  448.     WriteLine (EvalCodes^.Codes.BeginLine);
  449.     WriteText (f, EvalCodes^.Codes.Begin);
  450.     Node := Modules;
  451.     WHILE Node^.Kind = Tree.Module DO
  452.        WriteLine (Node^.Module.EvalCodes^.Codes.BeginLine);
  453.        WriteText (f, Node^.Module.EvalCodes^.Codes.Begin);
  454.        Node := Node^.Module.Next;
  455.     END;
  456.     WriteS (f, "}"); WriteNl (f);
  457.     WriteNl (f);
  458.     WriteS (f, "void Close"); WI (EvalName); WriteS (f, " ()"); WriteNl (f);
  459.     WriteS (f, "{"); WriteNl (f);
  460.     WriteLine (EvalCodes^.Codes.CloseLine);
  461.     WriteText (f, EvalCodes^.Codes.Close);
  462.     Node := Modules;
  463.     WHILE Node^.Kind = Tree.Module DO
  464.        WriteLine (Node^.Module.EvalCodes^.Codes.CloseLine);
  465.        WriteText (f, Node^.Module.EvalCodes^.Codes.Close);
  466.        Node := Node^.Module.Next;
  467.     END;
  468.     WriteS (f, "}"); WriteNl (f);
  469. ;
  470.       RETURN;
  471.      END;
  472.  
  473.   END;
  474.  END EvalImplC;
  475.  
  476. PROCEDURE TypeName (t: Tree.tTree);
  477.  VAR yyTempo: RECORD CASE : INTEGER OF
  478.  END; END;
  479.  BEGIN
  480.   IF t = Tree.NoTree THEN RETURN; END;
  481.   IF (t^.Kind = Tree.Class) THEN
  482. (* line 313 "" *)
  483.    LOOP
  484.      WITH t^.Class DO
  485. (* line 314 "" *)
  486.       IF NOT (NoCodeClass * Properties = {}) THEN EXIT; END;
  487. (* line 315 "" *)
  488.       IF NOT (Trace IN Properties) THEN EXIT; END;
  489. (* line 316 "" *)
  490.       WriteS (f, '"');
  491. (* line 316 "" *)
  492.       WI (Name);
  493. (* line 316 "" *)
  494.       WriteS (f, '",');
  495. (* line 316 "" *)
  496.       WriteNl (f);
  497.       RETURN;
  498.      END;
  499.    END;
  500.  
  501.   END;
  502.  END TypeName;
  503.  
  504. PROCEDURE GenEvaluator (t: Tree.tTree);
  505.  VAR yyTempo: RECORD CASE : INTEGER OF
  506.  | 8: yyR8: RECORD
  507.   TheClass: Tree.tTree;
  508.   k: INTEGER;
  509.   END;
  510.  END; END;
  511.  BEGIN
  512.   IF t = Tree.NoTree THEN RETURN; END;
  513.  
  514.   CASE t^.Kind OF
  515.   | Tree.Class:
  516. (* line 321 "" *)
  517.    LOOP
  518.      WITH t^.Class DO
  519. (* line 322 "" *)
  520.       IF NOT (NoCodeClass * Properties = {}) THEN EXIT; END;
  521. (* line 323 "" *)
  522.           IF (Generated = InstCount) OR (Visits < n) THEN RETURN; END;
  523.     WriteNl (f);
  524.     WriteS (f, "case k"); WI (Name); WriteS (f, ":"); WriteNl (f);
  525.     Class := t;
  526.     LOOP
  527.        IF Generated = InstCount THEN EXIT; END;
  528.        INC (Generated);
  529.        WITH Instance^ [Instance^ [Generated].Order] DO
  530.           IF (Left IN Properties) AND (Attribute^.Child.Partition > n) THEN
  531.              DEC (Generated); EXIT;
  532.           END;
  533.           IF ({Inherited, Right, First} <= Properties) AND NOT (Virtual IN Properties) THEN
  534.       IF IsElement (ORD ('X'), Options) AND (Trace IN t^.Class.Properties) THEN
  535.          WriteS (f, 'yyWriteEval (yyt, "'); WI (Selector^.Child.Name); WriteS (f, ":"); WI (Attribute^.Child.Name); WriteS (f, '");'); WriteNl (f);
  536.          IF Action # ADR (Action) THEN GenEvaluator (Action); END; WriteNl (f);
  537.          IF (Attribute^.Kind = Tree.Child) OR (Attribute^.Attribute.Type = itTree) THEN
  538.             WriteS (f, "write"); WI (itTree);
  539.             WriteS (f, " (yyt->"); WI (Name); WriteS (f, "."); WI (Selector^.Child.Name);
  540.             WriteS (f, "->"); WI (Selector^.Child.Type); WriteS (f, "."); WI (Attribute^.Child.Name); WriteS (f, ")"); WriteNl (f);
  541.          ELSE
  542.             WriteS (f, "write"); WI (Attribute^.Child.Type);
  543.             WriteS (f, " (yyt->"); WI (Name); WriteS (f, "."); WI (Selector^.Child.Name);
  544.             WriteS (f, "->"); WI (Selector^.Child.Type); WriteS (f, "."); WI (Attribute^.Child.Name); WriteS (f, ") yyWriteNl ();"); WriteNl (f);
  545.          END;
  546.       ELSIF IsElement (ORD ('Y'), Options) AND (Trace IN t^.Class.Properties) THEN
  547.          WriteS (f, 'yyWriteEval (yyt, "'); WI (Selector^.Child.Name); WriteS (f, ":"); WI (Attribute^.Child.Name); WriteS (f, '");'); WriteNl (f);
  548.          IF Action # ADR (Action) THEN GenEvaluator (Action); END;
  549.       ELSE
  550.          IF Action # ADR (Action) THEN GenEvaluator (Action); END;
  551.       END;
  552.           END;
  553.           IF ({Synthesized, Left, First} <= Properties) AND ({Dummy, Virtual} * Properties = {}) THEN
  554.       IF IsElement (ORD ('X'), Options) AND (Trace IN t^.Class.Properties) THEN
  555.          WriteS (f, 'yyWriteEval (yyt, "'); WI (Attribute^.Child.Name); WriteS (f, '");'); WriteNl (f);
  556.          IF Action # ADR (Action) THEN GenEvaluator (Action); END; WriteNl (f);
  557.          IF Test IN Properties THEN
  558.             WriteS (f, "writebool (yyb) yyWriteNl ();"); WriteNl (f);
  559.          ELSIF (Attribute^.Kind = Tree.Child) OR (Attribute^.Attribute.Type = itTree) THEN
  560.             WriteS (f, "write"); WI (itTree);
  561.             WriteS (f, " (yyt->"); WI (Name); WriteS (f, "."); WI (Attribute^.Child.Name); WriteS (f, ")"); 
  562.          ELSE
  563.             WriteS (f, "write"); WI (Attribute^.Child.Type);
  564.             WriteS (f, " (yyt->"); WI (Name); WriteS (f, "."); WI (Attribute^.Child.Name); WriteS (f, ") yyWriteNl ();"); WriteNl (f);
  565.          END;
  566.       ELSIF IsElement (ORD ('Y'), Options) AND (Trace IN t^.Class.Properties) THEN
  567.          WriteS (f, 'yyWriteEval (yyt, "'); WI (Attribute^.Child.Name); WriteS (f, '");'); WriteNl (f);
  568.          IF Action # ADR (Action) THEN GenEvaluator (Action); END;
  569.       ELSE
  570.          IF Action # ADR (Action) THEN GenEvaluator (Action); END;
  571.       END;
  572.           END;
  573.           IF ({Synthesized, Right, First} <= Properties) AND
  574.          (Attribute^.Child.Partition <= Selector^.Child.Class^.Class.Visits) THEN
  575.       IF IsElement (ORD ('Z'), Options) AND (Trace IN t^.Class.Properties) THEN
  576.          WriteS (f, 'yyWriteVisit (yyt, "'); WI (Selector^.Child.Name); WriteS (f, " "); 
  577.          WN (Attribute^.Child.Partition); WriteS (f, '");'); WriteNl (f);
  578.       END;
  579.          WriteS (f, "yyVisit"); WN (Attribute^.Child.Partition);
  580.          WriteS (f, " (yyt->"); WI (Name); WriteS (f, "."); WI (Selector^.Child.Name); WriteS (f, ");"); WriteNl (f);
  581.           END;
  582.        END;
  583.     END;
  584.       IF IsElement (ORD ('Z'), Options) AND (Trace IN t^.Class.Properties) THEN
  585.     WriteS (f, "yyVisitParent (yyt);"); WriteNl (f);
  586.       END;
  587.     WriteS (f, "break;"); WriteNl (f);
  588. ;
  589.       RETURN;
  590.      END;
  591.    END;
  592.  
  593.   | Tree.Assign:
  594. (* line 390 "" *)
  595.      WITH t^.Assign DO
  596. (* line 390 "" *)
  597.       
  598.     WriteLine (Pos);
  599.     GenEvaluator (Results); WriteS (f, "="); GenEvaluator (Arguments); WriteS (f, ";"); WriteNl (f);
  600. ;
  601.       RETURN;
  602.      END;
  603.  
  604.   | Tree.Copy:
  605. (* line 394 "" *)
  606.      WITH t^.Copy DO
  607. (* line 394 "" *)
  608.       
  609.     WriteLine (Pos);
  610.     GenEvaluator (Results); WriteS (f, "="); GenEvaluator (Arguments); WriteS (f, ";"); WriteNl (f);
  611. ;
  612.       RETURN;
  613.      END;
  614.  
  615.   | Tree.TargetCode:
  616. (* line 398 "" *)
  617.      WITH t^.TargetCode DO
  618. (* line 398 "" *)
  619.       
  620.     WriteLine (Pos);
  621.     GenEvaluator (Code); WriteNl (f);
  622. ;
  623.       RETURN;
  624.      END;
  625.  
  626.   | Tree.Check:
  627. (* line 402 "" *)
  628.      WITH t^.Check DO
  629. (* line 402 "" *)
  630.       
  631.     WriteLine (Pos);
  632.     IF Condition # NoTree THEN
  633.        WriteS (f, 'if (! ('); 
  634.       IF IsElement (ORD ('X'), Options) THEN
  635.        WriteS (f, "yyb = "); 
  636.       END;
  637.        GenEvaluator (Condition); WriteS (f, ")) {"); GenEvaluator (Statement); WriteS (f, "; }"); WriteNl (f);
  638.        IF Actions^.Kind = Tree.Check THEN
  639.           WriteS (f, "else"); WriteNl (f);
  640.           GenEvaluator (Actions);
  641.        END;
  642.     ELSE
  643.       IF IsElement (ORD ('X'), Options) THEN
  644.        WriteS (f, "yyb = false; "); 
  645.       END;
  646.        GenEvaluator (Statement); WriteS (f, ";"); WriteNl (f);
  647.        GenEvaluator (Actions);
  648.     END;
  649. ;
  650.       RETURN;
  651.      END;
  652.  
  653.   | Tree.Designator:
  654. (* line 422 "" *)
  655.      WITH t^.Designator DO
  656. (* line 422 "" *)
  657.       
  658.     Attr := IdentifyAttribute (Class, Selector);
  659.     IF Attr # NoTree THEN
  660.        ChildsClass := Attr^.Child.Class;
  661.        Attr := IdentifyAttribute (ChildsClass, Attribute);
  662.        IF NOT (Virtual IN Attr^.Attribute.Properties) THEN
  663.           WriteS (f, "yyt->"); WI (Class^.Class.Name); WriteS (f, "."); WI (Selector); WriteS (f, "->"); 
  664.           WI (ChildsClass^.Class.Name); WriteS (f, "."); WI (Attribute);
  665.        END;
  666.     ELSE
  667.        WI (Selector); WriteS (f, ":"); WI (Attribute);
  668.     END;
  669.     GenEvaluator (Next);
  670. ;
  671.       RETURN;
  672.      END;
  673.  
  674.   | Tree.Ident:
  675. (* line 436 "" *)
  676.      WITH t^.Ident DO
  677. (* line 436 "" *)
  678.       
  679.     Attr := IdentifyAttribute (Class, Attribute);
  680.     IF Attr # NoTree THEN
  681.        IF NOT (Virtual IN Attr^.Attribute.Properties) THEN
  682.           WriteS (f, "yyt->"); WI (Class^.Class.Name); WriteS (f, "."); WI (Attribute);
  683.        END;
  684.     ELSE
  685.        WI (Attribute);
  686.     END;
  687.     GenEvaluator (Next);
  688. ;
  689.       RETURN;
  690.      END;
  691.  
  692.   | Tree.Remote:
  693. (* line 447 "" *)
  694.     WITH yyTempo.yyR8 DO
  695.      WITH t^.Remote DO
  696. (* line 448 "" *)
  697.       ;
  698. (* line 448 "" *)
  699.       ;
  700. (* line 449 "" *)
  701.       TheClass := IdentifyClass (TreeRoot ^ . Ag . Classes, Type);
  702. (* line 450 "" *)
  703.         IF TheClass # NoTree THEN
  704.       Attr := IdentifyAttribute (TheClass, Attribute);
  705.       IF Attr # NoTree THEN
  706.      WITH Attr^.Attribute DO
  707.         k := ToBit0 (TheClass, AttrIndex);
  708.         IF Synthesized IN Properties THEN
  709.            WriteS (f, "REMOTE_SYN (yyIsComp"); WN (k DIV BSS); WriteS (f, ", "); WN (k MOD BSS); WriteS (f, ", yyS"); WN (k); WriteS (f, ", "); 
  710.            GenEvaluator (Designators); WriteS (f, ", "); WI (t^.Remote.Type); WriteS (f, ", "); WI (Attribute); WriteS (f, ")"); 
  711.         ELSIF Inherited IN Properties THEN
  712.            WriteS (f, "REMOTE_INH (yyIsComp"); WN (k DIV BSS); WriteS (f, ", "); WN (k MOD BSS); WriteS (f, ", "); WN (k); WriteS (f, ", "); 
  713.            GenEvaluator (Designators); WriteS (f, ", "); WI (t^.Remote.Type); WriteS (f, ", "); WI (Attribute); WriteS (f, ")"); 
  714.         ELSE
  715.            GenEvaluator (Designators); WriteS (f, "->"); WI (t^.Remote.Type); WriteS (f, "."); WI (Attribute);
  716.         END;
  717.      END;
  718.       END;
  719.    END;
  720.    GenEvaluator (Next);
  721. ;
  722.       RETURN;
  723.      END;
  724.     END;
  725.  
  726.   | Tree.Any:
  727. (* line 469 "" *)
  728.      WITH t^.Any DO
  729. (* line 469 "" *)
  730.       
  731.     WriteString (f, Code);
  732.     GenEvaluator (Next);
  733. ;
  734.       RETURN;
  735.      END;
  736.  
  737.   | Tree.Anys:
  738. (* line 473 "" *)
  739.      WITH t^.Anys DO
  740. (* line 473 "" *)
  741.       
  742.     GenEvaluator (Layouts);
  743.     GenEvaluator (Next);
  744. ;
  745.       RETURN;
  746.      END;
  747.  
  748.   | Tree.LayoutAny:
  749. (* line 477 "" *)
  750.      WITH t^.LayoutAny DO
  751. (* line 477 "" *)
  752.       
  753.     WriteString (f, Code);
  754.     GenEvaluator (Next);
  755. ;
  756.       RETURN;
  757.      END;
  758.  
  759.   ELSE END;
  760.  
  761.  END GenEvaluator;
  762.  
  763. PROCEDURE BeginEvalC;
  764.  BEGIN
  765.  END BeginEvalC;
  766.  
  767. PROCEDURE CloseEvalC;
  768.  BEGIN
  769.  END CloseEvalC;
  770.  
  771. PROCEDURE yyExit;
  772.  BEGIN
  773.   IO.CloseIO; System.Exit (1);
  774.  END yyExit;
  775.  
  776. BEGIN
  777.  yyf    := IO.StdOutput;
  778.  Exit    := yyExit;
  779.  BeginEvalC;
  780. END EvalC.
  781.